\section{Ap\'endice B}
\subsection{Main}
{\ttfamily \raggedright \small
\textsl{//============================================================================}\\
\textsl{//\ Name\ \ \ \ \ \ \ \ :\ tp2.cpp}\\
\textsl{//\ Author\ \ \ \ \ \ :\ jk,\ as,\ md}\\
\textsl{//\ Version\ \ \ \ \ :}\\
\textsl{//\ Copyright\ \ \ :}\\
\textsl{//\ Description\ :}\\
\textsl{//============================================================================}\\
\ \\
\#include\ <{}iostream>{}\\
\#include\ <{}fstream>{}\\
\#include\ "{}espionaje.h"{}\\
\#include\ "{}localizador.h"{}\\
\#include\ "{}disparar.h"{}\\
using\ namespace\ std;\\
\ \\
int\ main(int\ argc,\ char$\ast$\ argv\ [])\\
\{
\\
\ \ Espionaje\ espia(argv[1],argv[2]);\\
\ \ int\ dimension\ =\ espia.getDimension();\\
\ \ Matriz\ $\ast$enemigo\ =\ new\ Matriz(dimension,dimension);\\
\ \ Matriz\ $\ast$impacto\ =\ new\ Matriz(dimension,1);\\
\ \ Matriz\ $\ast$sol\ =\ new\ Matriz(dimension,1);
\\
\ \ Matriz\ $\ast$nueva\ =\ new\ Matriz(dimension,dimension);\\
\ \\
\ \ Localizador\ localizar;\\
\ \ Disparar\ disparo(dimension,espia.getPosicionNuestra());\\
\ \ if(espia.getTurno()==0)\\
\ \ \{\\
\ \ \ \ disparo.getPrimerDisparo(sol);\\
\ \ \ \ disparo.getPrimerTransformacion(nueva);\\
\ \ \ \ espia.setDisparo(sol);\\
\ \ \ \ espia.setTransformacion(nueva);\\
\ \ \}\\
\ \ else\\
\ \ \{\\
\ \ \ \ impacto\ =\ espia.getPosicionImpacto();\\
\ \ \ \ enemigo\ =\ espia.getMatrizEnemigo();\\
\ \ \ \ localizar.getPosicionObjetivo($\ast$impacto,$\ast$enemigo,$\ast$sol);\\
\ \ \ \ disparo.getTransformacion(sol,nueva);\\
\ \ \ \ espia.setDisparo(sol);\\
\ \ \ \ espia.setTransformacion(nueva);\\
\ \ \}
\\

\ \ \ \ fstream\ info;
\\
\ \ info.open(INFO,ios::out\ |\ ios::app);
\\
\ \ info<{}<{}espia.getTurno()<{}<{}endl;
\\
\ \ for(Tam\ i=1;i<{}=nueva-{}>{}cantidadDeFilas();i++)
\\
\ \ \{
\\
\ \ \ \ \ \ for(Tam\ j=1;j<{}=nueva-{}>{}cantidadDeColumnas();j++)
\\
\ \ \ \ \ \ \{
\\
\ \ \ \ \ \ \ \ \ \ \ \ info<{}<{}nueva-{}>{}get(i,j);
\\
\ \ \ \ \ \ \ \ \ \ \ \ info<{}<{}'\ ';
\\
\ \ \ \ \ \ \}
\\
\ \ \ \ \ \ \ \ \ \ \ \ info<{}<{}';'<{}<{}endl;
\\
\ \ \}
\\

\ \ \ \ for(Tam\ j=1;j<{}=sol-{}>{}cantidadDeFilas();j++)
\\
\ \ \{
\\
\ \ \ \ info<{}<{}sol-{}>{}get(j,1);
\\
\ \ \ \ info<{}<{}'\ ';
\\
\ \ \}
\\
\ \ info<{}<{}endl;
\\

\ \ info.close();
\\
\ \\
\ \ espia.escribirDisparo();\\
\ \\
\ \ delete\ sol;\\
\ \ delete\ impacto;\\
\ \ delete\ enemigo;\\
\ \\
\ \ return\ 0;\\
\}\\
\ \\
 }
\normalfont\normalsize


\subsection{Matriz Abstracta}
{\ttfamily \raggedright \small
\#ifndef MATRIZABASTRACTA\underline\ H\underline\ \\
\#define MATRIZABASTRACTA\underline\ H\underline\ \\
\#include\ <{}iostream>{}\\
\ \\
typedef\ unsigned\ int\ Uint;\\
typedef\ Uint\ Indice;\\
typedef\ Uint\ Tam;\\
\ \\
using\ namespace\ std;\\
\ \\
\textsl{/$\ast$$\ast$\\
\ $\ast$ Clase\ base\ para\ las\ matrices.\\
\ $\ast$ La\ idea\ es\ que\ los\ algoritmos\ utilicen\ MatrizAbstracta\ \\
\ $\ast$ para\ abstraerse\ de\ cualquier\ implementación\ posterior.\\
\ $\ast$/}\\
class\ MatrizAbstracta\ \{\\
\ \ public\ :\\
\ \ \ \ \ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Devuelve\ el\ valor\ de\ la\ matriz\ en\ la\ posición\ indicada.\\
\ \ \ \ \ $\ast$ @param\ i\ Fila\ i-{}esima\ de\ la\ matriz.\\
\ \ \ \ \ $\ast$ @param\ j\ Columna\ j-{}esima\ de\ la\ matriz.\\
\ \ \ \ \ $\ast$ @return\ El\ valor\ de\ la\ matriz\ en\ la\ fila\ i\ y\ la\ columna\ j.\\
\ \ \ \ \ $\ast$ @remarks\ Los\ indices\ comienzan\ desde\ uno.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ virtual\ double\ get(Indice\ fila,\ Indice\ columna)\ const\ =\ 0;\\
\ \\
\ \ \ \ \ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Establece\ el\ valor\ de\ la\ matriz\ en\ la\ posición\ indicada.\\
\ \ \ \ \ $\ast$ @param\ i\ Fila\ i-{}esima\ de\ la\ matriz.\\
\ \ \ \ \ $\ast$ @param\ j\ Columna\ j-{}esima\ de\ la\ matriz.\\
\ \ \ \ \ $\ast$ @param\ valor\ El\ nuevo\ valor\ de\ la\ matriz\ en\ la\ fila\ i\ y\ la\ columna\ j.\\
\ \ \ \ \ $\ast$ @remarks\ Los\ indices\ comienzan\ desde\ uno.\ Además\ notar\ que\ no\ es\ \\
\ \ \ \ \ $\ast$ virtual\ PURA,\ esto\ es\ debido\ a\ que\ las\ matrices\ derivadas\ tal\ vez\ no\ necesiten\\
\ \ \ \ \ $\ast$ implementar\ el\ método\ set,\ es\ decir\ serían\ una\ especie\ de\ matriz\ de\\
\ \ \ \ \ $\ast$ solo\ lectura.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ virtual\ void\ set(Indice\ fila,\ Indice\ columna,\ double\ valor);\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Devuelve\ la\ cantidad\ de\ filas\ de\ la\ matriz.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ virtual\ Tam\ cantidadDeFilas()\ const\ =\ 0;\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Devuelve\ la\ cantidad\ de\ columnas\ de\ la\ matriz.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ virtual\ Tam\ cantidadDeColumnas()\ const\ =\ 0;\\
\ \ \ \ \\
\ \ \ \ \textsl{//virtual\ void\ copiarMatriz(const\ MatrizAbstracta$\ast$\ m);}\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Método\ abreviado\ para\ la\ operación\ get.\\
\ \ \ \ \ $\ast$ Si\ bien\ en\ C++\ los\ paréntesis\ se\ utilizan\ para\ llamadas\ a\ función,\\
\ \ \ \ \ $\ast$ cambiarle\ la\ semántica\ para\ que\ devuelva\ el\ valor\ en\ la\ posición\ Mij\\
\ \ \ \ \ $\ast$ no\ presenta\ un\ cambio\ dramático,\ ya\ que\ en\ matemáticas\ esta\\
\ \ \ \ \ $\ast$ notación\ es\ habitual.\\
\ \ \ \ \ $\ast$ No\ se\ utilizo\ la\ sobrecarga\ del\ operador\ [],\ por\ que\ no\ puede\ recibir\\
\ \ \ \ \ $\ast$ dos\ parámetros.\\
\ \ \ \ \ $\ast$ @see\ get\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ double\ operator()(Indice\ i,\ Indice\ j)\ const;\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Suma\ a\ la\ fila\ filaDestino\ un\ multiplo\ (factor)\ de\ la\ filaOrigen.\\
\ \ \ \ \ $\ast$ Esta\ operación\ es\ una\ operación\ entre\ filas\ de\ la\ matriz\ y\ se\\
\ \ \ \ \ $\ast$ utliza\ para\ factorizarla.\\
\ \ \ \ \ $\ast$ @param\ filaOrigen\ Fila\ origen\ de\ la\ matriz.\\
\ \ \ \ \ $\ast$ @param\ filaDestino\ Fila\ destino\ de\ la\ matriz.\\
\ \ \ \ \ $\ast$ @param\ factor\ Factor\ para\ multiplicar\ a\ la\ fila\ filaOrigen.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ void\ sumaMultiplo(\\
\ \ \ \ \ \ Indice\ filaOrigen,\\
\ \ \ \ \ \ Indice\ filaDestino,\\
\ \ \ \ \ \ double\ factor,\\
\ \ \ \ \ \ Indice\ columnaDesde,\\
\ \ \ \ \ \ Indice\ columnaHasta\\
\ \ \ \ );\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Sobrecarga\ de\ sumaMultiplo,\ donde\ columnaDesde\ =\ 1\ y\\
\ \ \ \ \ $\ast$ columnaHasta\ =\ cantidadDeColumnas()\\
\ \ \ \ \ $\ast$ @param\ filaOrigen\ Fila\ origen\ de\ la\ matriz.\\
\ \ \ \ \ $\ast$ @param\ filaDestino\ Fila\ destino\ de\ la\ matriz.\\
\ \ \ \ \ $\ast$ @param\ factor\ Factor\ para\ multiplicar\ a\ la\ fila\ filaOrigen.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ void\ sumaMultiplo(\\
\ \ \ \ \ \ Indice\ filaOrigen,\\
\ \ \ \ \ \ Indice\ filaDestino,\\
\ \ \ \ \ \ double\ factor\\
\ \ \ \ );\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Serialización\ de\ la\ matriz.\ \\
\ \ \ \ \ $\ast$ El\ formato\ utilizado\ es\ de\ Matlab.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ ostream\&\ serializate(ostream\&\ o,\ bool\ conFormatoMatlab\ =\ true)\ const;\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Sobrecarga\ del\ operador\ <{}<{}.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ friend\ ostream\&\ operator<{}<{}(ostream\&\ o,\ const\ MatrizAbstracta\&\ m);\\
\};\\
\ \\
\#endif /$\ast$MATRIZABASTRACTA\underline\ H\underline\ $\ast$/\\
\ \\
 }
\normalfont\normalsize


{\ttfamily \raggedright \small
\#include\ "{}matrizabstracta.h"{}\\
\#include\ <{}cassert>{}\\
\#include\ <{}iomanip>{}\\
\ \\
\textsl{/$\ast$\\
\ $\ast$ set\\
\ $\ast$/}\\
void\ MatrizAbstracta::set(Indice\ i,\ Indice\ j,\ double\ valor)\ \{\\
\}\\
\ \\
\textsl{/$\ast$\\
\ $\ast$ operator()\\
\ $\ast$/}\\
double\ MatrizAbstracta::operator()(Indice\ i,\ Indice\ j)\ const\ \{\\
\ \ return\ get(i,\ j);\\
\}\\
\ \\
\textsl{/$\ast$\\
\ $\ast$ sumaMultiplo\\
\ $\ast$/}\\
void\ MatrizAbstracta::sumaMultiplo(\\
\ \ Indice\ filaOrigen,\\
\ \ Indice\ filaDestino,\\
\ \ double\ factor,\ \\
\ \ Indice\ columnaDesde,\\
\ \ Indice\ columnaHasta\\
)\ \{\\
\ \ assert(1\ <{}=\ columnaDesde\ \&\&\ columnaHasta\ <{}=\ cantidadDeColumnas());\\
\ \ \textsl{//MatrizAbstracta\&\ t\ =\ $\ast$this;}\\
\ \ for\ (Indice\ j\ =\ columnaDesde;\ j\ <{}=\ columnaHasta;\ j++)\ \{\\
\ \ \ \ set(filaDestino,\ j,\ get(filaDestino,\ j)\ +\ factor\ $\ast$\ get(filaOrigen,\ j)\ );\\
\ \ \}\\
\}\\
\ \\
\textsl{/$\ast$\\
\ $\ast$ sumaMultiplo\\
\ $\ast$/}\\
void\ MatrizAbstracta::sumaMultiplo(\\
\ \ Indice\ filaOrigen,\\
\ \ Indice\ filaDestino,\\
\ \ double\ factor\\
)\ \{\\
\ \ sumaMultiplo(filaOrigen,\ filaDestino,\ factor,\ 1,\ cantidadDeColumnas());\\
\}\\
\ \\
\textsl{/$\ast$\\
\ $\ast$ serializate\\
\ $\ast$/}\\
\ \\
ostream\&\ MatrizAbstracta::serializate(ostream\&\ o,\ bool\ conFormatoMatlab)\ const\ \{\\
\ \ const\ MatrizAbstracta\&\ m\ =\ $\ast$this;\\
\ \\
\ \ if\ (conFormatoMatlab)\ \{\\
\ \ \ \ o\ <{}<{}\ "{}\ [\ "{};\\
\ \ \}\\
\ \\
\ \ for\ (Uint\ i\ =\ 1;\ i\ <{}=\ m.cantidadDeFilas();\ i++)\ \{\\
\ \ \ \ for\ (Uint\ j\ =\ 1;\ j\ <{}=\ m.cantidadDeColumnas();\ j++)\ \{\\
\ \ \ \ \ \ o\ <{}<{}\ m(i,\ j)\ <{}<{}\ "{}\ "{};\\
\ \ \ \ \}\\
\ \ \ \ o\ <{}<{}\ (conFormatoMatlab\ ?\ "{};"{}\ :\ "{}"{})\ <{}<{}\ endl;\\
\ \ \}\\
\ \ return\ o\ <{}<{}\ (conFormatoMatlab\ ?\ "{}\ ];"{}:\ "{}"{});\\
\}\\
\textsl{/$\ast$\\
\ $\ast$ operator<{}<{}\\
\ $\ast$/}\\
ostream\&\ operator<{}<{}(ostream\&\ o,\ const\ MatrizAbstracta\&\ m)\ \{\\
\ \ return\ m.serializate(o);\\
\}\\
\ \\
 }
\normalfont\normalsize


\subsection{Matriz}
{\ttfamily \raggedright \small
\#ifndef MATRIZ\underline\ H\underline\ \\
\#define MATRIZ\underline\ H\underline\ \\
\ \\
\#include\ <{}vector>{}\\
\#include\ "{}matrizabstracta.h"{}\\
\ \\
using\ namespace\ std;\\
\ \\
\textsl{/$\ast$$\ast$\\
\ $\ast$ Implementación\ trivial\ de\ MatrizAbstracta.\\
\ $\ast$/}\\
class\ Matriz\ :\ public\ MatrizAbstracta\ \{\\
\ \ public\ :\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Constructor\ por\ defecto\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ Matriz(Tam\ cantidadDeFilas\ =\ 0,\ Tam\ cantidadDeColumnas\ =\ 0);\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Implementación\ del\ método\ get.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ double\ get(Indice\ fila,\ Indice\ columna)\ const;\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Implementación\ del\ método\ set.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ void\ set(Indice\ fila,\ Indice\ columna,\ double\ valor);\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Devuelve\ la\ cantidad\ de\ filas\ de\ la\ matriz.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ Tam\ cantidadDeFilas()\ const;\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Devuelve\ la\ cantidad\ de\ columnas\ de\ la\ matriz.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ Tam\ cantidadDeColumnas()\ const;\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ \ $\ast$ Establece\ el\ tamaño\ del\ parabrisas.\\
\ \ \ \ \ $\ast$/}\\
\ \ \ \ void\ setTam(Tam\ cantidadDeFilas,\ Tam\ cantidadDeColumnas);\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ $\ast$ Devuelve\ la\ posicion\ del\ maximo\ elemento\ (absoluto)\ de\ la\ submatriz\\
\ \ \ \ $\ast$/}\\
\ \ \ \ void\ getPosicionMaxElementoSubmatriz(Indice\ submatriz,\ Indice\&\ fila,\ Indice\&\ columna);\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ $\ast$ Intercambia\ las\ columnas\\
\ \ \ \ $\ast$/}\\
\ \ \ \ void\ swapColumna(Indice\ columna1,\ Indice\ columna2);\\
\ \\
\ \ \ \ \textsl{/$\ast$$\ast$\\
\ \ \ \ $\ast$ Intercambia\ las\ filas\\
\ \ \ \ $\ast$/}\\
\ \ \ \ void\ swapFila(Indice\ fila1,\ Indice\ fila2);\\
\ \ \ \ \\
\ \ \ \ void\ copiarMatriz(const\ Matriz$\ast$\ m);\\
\ \ \ \ \\
\ \ \ \ void\ trasponer();\\
\ \\
\ \ private\ :\\
\ \ \ \ Tam\ \ \ \ \ \ \ \ \underline\ cantidadDeFilas;\\
\ \ \ \ Tam\ \ \ \ \ \ \ \ \underline\ cantidadDeColumnas;\\
\ \ \ \ vector<{}double>{}\ \ \underline\ vector;\\
\};\\
\ \\
\#endif /$\ast$MATRIZ\underline\ H\underline\ $\ast$/\\
\ \\
 }
\normalfont\normalsize


{\ttfamily \raggedright \small
\#include\ "{}matriz.h"{}\\
\#include\ <{}math.h>{}\\
\#include\ <{}cassert>{}\\
\#include\ <{}cmath>{}\\
\ \\
\textsl{/$\ast$\\
\ $\ast$ Mapea\ coordenadas\ de\ una\ matriz\ con\ subindices\ que\ comienzan\\
\ $\ast$ desde\ 1\ a\ coordenadas\ para\ un\ vector\ que\ comienza\ en\ 0.\\
\ $\ast$/}\\
Indice\ deCoordsAIndice(Indice\ i,\ Indice\ j,\ Tam\ m)\ \{\\
\ \ return\ (i\ -{}\ 1)\ $\ast$\ m\ +\ j\ -{}\ 1;\\
\}\\
\ \\
\textsl{/$\ast$\\
\ $\ast$ Matriz\\
\ $\ast$/}\\
Matriz::Matriz(Tam\ cantidadDeFilas,\ Tam\ cantidadDeColumnas)\ :\\
\ \ \underline\ cantidadDeFilas\ \ (cantidadDeFilas),\\
\ \ \underline\ cantidadDeColumnas\ \ (cantidadDeColumnas),\\
\ \ \underline\ vector\ \ \ \ \ \ \ \ (\underline\ cantidadDeFilas\ $\ast$\ \underline\ cantidadDeColumnas)\\
\{\\
\ \ for\ (Indice\ i\ =\ 0;\ i\ <{}\ \underline\ vector.size();\ i++)\ \{\\
\ \ \ \ \underline\ vector[i]\ =\ 0;\\
\ \ \}\\
\}\\
\ \\
double\ Matriz::get(Indice\ i,\ Indice\ j)\ const\ \{\\
\ \ assert(1\ <{}=\ i\ \&\&\ i\ <{}=\ \underline\ cantidadDeFilas\ \&\&\ 1\ <{}=\ j\ \&\&\ j\ <{}=\ \underline\ cantidadDeColumnas);\\
\ \\
\ \ return\ \underline\ vector[deCoordsAIndice(i,\ j,\ \underline\ cantidadDeColumnas)];\\
\}\\
\ \\
void\ Matriz::set(Indice\ i,\ Indice\ j,\ double\ valor)\ \{\\
\ \ assert(1\ <{}=\ i\ \&\&\ i\ <{}=\ \underline\ cantidadDeFilas\ \&\&\ 1\ <{}=\ j\ \&\&\ j\ <{}=\ \underline\ cantidadDeColumnas);\\
\ \\
\ \ \underline\ vector[deCoordsAIndice(i,\ j,\ \underline\ cantidadDeColumnas)]\ =\ valor;\\
\}\\
\ \\
Tam\ Matriz::cantidadDeFilas()\ const\ \{\\
\ \ return\ \underline\ cantidadDeFilas;\\
\}\\
\ \\
Tam\ Matriz::cantidadDeColumnas()\ const\ \{\\
\ \ return\ \underline\ cantidadDeColumnas;\\
\}\\
\ \\
void\ Matriz::getPosicionMaxElementoSubmatriz(Indice\ submatriz,\ Indice\&\ fila,\ Indice\&\ columna)\{\\
\ \ Tam\ j,i;\\
\ \ fila=\ submatriz;\\
\ \ columna=\ submatriz;\\
\ \ double\ max,\ act;\\
\ \ max=\ fabs(this-{}>{}get(fila,\ columna));\\
\ \\
\ \ for(j=submatriz;j<{}=this-{}>{}cantidadDeFilas();j++)\{\\
\ \ \ \ for(i=submatriz;i<{}=this-{}>{}cantidadDeColumnas();i++)\{\ \ \ \ \\
\ \ \ \ \ \ act=\ fabs(this-{}>{}get(j,i));\\
\ \ \ \ \ \ if\ (max<{}act)\{\\
\ \ \ \ \ \ \ \ fila=\ j;\\
\ \ \ \ \ \ \ \ columna=\ i;\\
\ \ \ \ \ \ \ \ max=\ act;\\
\ \ \ \ \ \ \}\\
\ \ \ \ \}\\
\ \ \}\ \ \\
\}\\
\ \\
void\ Matriz::swapColumna(Indice\ columna1,\ Indice\ columna2)\{\\
\ \ double\ aux;\\
\ \ for(Tam\ i=1;i<{}=this-{}>{}cantidadDeFilas();i++)\{\\
\ \ \ \ aux=\ this-{}>{}get(i,columna1);\\
\ \ \ \ this-{}>{}set(i,columna1,this-{}>{}get(i,columna2));\\
\ \ \ \ this-{}>{}set(i,columna2,aux);\\
\ \ \}\\
\}\\
\ \\
void\ Matriz::swapFila(Indice\ fila1,\ Indice\ fila2)\{\\
\ \ double\ aux;\\
\ \ for(Tam\ i=1;i<{}=this-{}>{}cantidadDeColumnas();i++)\{\\
\ \ \ \ aux=\ this-{}>{}get(fila1,i);\\
\ \ \ \ this-{}>{}set(fila1,i,this-{}>{}get(fila2,\ i));\\
\ \ \ \ this-{}>{}set(fila2,i,aux);\\
\ \ \}\\
\}\\
\ \\
\textsl{/$\ast$\\
\ $\ast$ setTam\\
\ $\ast$/}\\
void\ Matriz::setTam(Tam\ cantidadDeFilas,\ Tam\ cantidadDeColumnas)\ \{\\
\ \ \underline\ cantidadDeFilas\ \ =\ cantidadDeFilas;\\
\ \ \underline\ cantidadDeColumnas\ \ =\ cantidadDeColumnas;\\
\ \ \underline\ vector.resize(\underline\ cantidadDeFilas\ $\ast$\ \underline\ cantidadDeColumnas);\\
\}\\
\ \\
void\ Matriz::copiarMatriz(const\ Matriz$\ast$\ m)\\
\{\\
\ \ if(\underline\ cantidadDeFilas\ !=\ m-{}>{}cantidadDeFilas()\ \&\&\ \underline\ cantidadDeColumnas\ !=\ m-{}>{}cantidadDeColumnas())\\
\ \ \ \ \ \ this-{}>{}setTam(m-{}>{}cantidadDeFilas(),m-{}>{}cantidadDeColumnas());\\
\ \ for(Indice\ j=1;j<{}=\underline\ cantidadDeColumnas;j++)\\
\ \ \ \ for(Indice\ i=1;i<{}=\underline\ cantidadDeFilas;i++)\\
\ \ \ \ \ \ this-{}>{}set(i,j,m-{}>{}get(i,j));\\
\}\\
\ \\
void\ Matriz::trasponer()\\
\{\\
\ \ Matriz\ m(this-{}>{}cantidadDeFilas(),this-{}>{}cantidadDeColumnas());\\
\ \ m.copiarMatriz(this);\\
\ \ this-{}>{}setTam(m.cantidadDeColumnas(),m.cantidadDeFilas());\\
\ \ for(Indice\ i=1;i<{}=this-{}>{}cantidadDeFilas();i++)\\
\ \ \ \ for(Indice\ j=1;j<{}=this-{}>{}cantidadDeColumnas();j++)\\
\ \ \ \ \ \ this-{}>{}set(i,j,m.get(j,i));\\
\ \ \\
\ \ \\
\}\\
\ \\
 }
\normalfont\normalsize


\subsection{Espionaje}
{\ttfamily \raggedright \small
\#ifndef ESPIONAJE\underline\ H\underline\ \\
\#define ESPIONAJE\underline\ H\underline\ \\
\#include\ "{}matriz.h"{}\\
\#include\ <{}iostream>{}\\
\#include\ <{}fstream>{}\\
\#include\ <{}vector>{}\\
\#include\ <{}stdlib.h>{}\\
using\ namespace\ std;\\
\#define INFO\ "{}info.txt"{}\\
class\ Espionaje\\
\{\\
\ \ private:\\
\ \ \ \ Tam\ \underline\ dimension;\\
\ \ \ \ int\ \underline\ turno;\\
\ \ \ \ fstream\ \underline\ info;\\
\ \ \ \ fstream\ \underline\ fileDatos;\\
\ \ \ \ fstream\ \underline\ fileDisparo;\\
\ \ \ \ Matriz\ $\ast$\underline\ posicion;\\
\ \ \ \ Matriz\ $\ast$\underline\ impacto;\\
\ \ \ \ Matriz\ $\ast$\underline\ transEnemigo;\\
\ \ \ \ Matriz\ $\ast$\underline\ nuestroDisparo;\\
\ \ \ \ Matriz$\ast$\ \underline\ nuestraTransformacion;\\
\ \ \ \ void\ llenarFila(int\ f,fstream\&\ fila,Matriz$\ast$\ m);\\
\ \ \ \ void\ escribirFila(int\ f,fstream\&\ fila,Matriz$\ast$\ m);\\
\ \\
\ \ public:\\
\ \ \ \ Espionaje(char$\ast$\ d,char$\ast$\ disp);\\
\ \ \ \ int\ getDimension()\ const;\\
\ \ \ \ int\ getTurno()\ const;\\
\ \ \ \ Matriz$\ast$\ getPosicionNuestra()\ const;\\
\ \ \ \ Matriz$\ast$\ getPosicionImpacto()\ const;\\
\ \ \ \ Matriz$\ast$\ getMatrizEnemigo()\ const;\\
\ \ \ \ void\ escibirInformacionAdicional();\\
\ \ \ \ void\ escribirDisparo();\\
\ \ \ \ void\ setDisparo(const\ Matriz$\ast$\ disparo);\\
\ \ \ \ void\ setTransformacion(const\ Matriz$\ast$\ transformacion);\\
\ \ \ \ \textasciitilde Espionaje();\\
\};\\
\ \\
\#endif /$\ast$ESPIONAJE\underline\ H\underline\ $\ast$/\\
\ \\
 }
\normalfont\normalsize


{\ttfamily \raggedright \small
\#include\ "{}espionaje.h"{}\\
\ \\
void\ Espionaje::llenarFila(int\ f,fstream\&\ fila,Matriz$\ast$\ m)\\
\{\\
\ \ string\ numero;\\
\ \ for(Tam\ j=1;j<{}=m-{}>{}cantidadDeColumnas();j++)\\
\ \ \{\\
\ \ \ \ fila>{}>{}numero;\\
\ \ \ \ m-{}>{}set(f,j,atof(numero.c\underline\ str()));\\
\ \ \}\\
\}\\
\ \\
void\ Espionaje::escribirFila(int\ f,fstream\&\ fila,Matriz$\ast$\ m)\\
\{\\
\ \ for(Tam\ j=1;j<{}=m-{}>{}cantidadDeColumnas();j++)\\
\ \ \{\\
\ \ \ \ fila<{}<{}m-{}>{}get(f,j);\\
\ \ \ \ fila<{}<{}'\ ';\\
\ \ \}\\
\ \ fila<{}<{}endl;\\
\}\\
\ \\
Espionaje::Espionaje(char$\ast$\ d,char$\ast$\ disp)\\
\{\\
\ \ \underline\ posicion=NULL;\\
\ \ \underline\ impacto=NULL;\\
\ \ \underline\ transEnemigo=NULL;\\
\ \ \underline\ nuestraTransformacion=NULL;\\
\ \ \underline\ nuestroDisparo=NULL;\\
\ \ \underline\ fileDatos.open(d);\\
\ \ \underline\ fileDisparo.open(disp,ios::out);\\
\ \ \underline\ fileDatos>{}>{}\underline\ turno;\\
\ \ \underline\ fileDatos>{}>{}\underline\ dimension;\\
\ \ \underline\ posicion\ =\ new\ Matriz(1,\underline\ dimension);\\
\ \\
\ \ if(\underline\ turno\ ==\ 0)\\
\ \ \{\\
\ \ \ \ llenarFila(1,\underline\ fileDatos,\underline\ posicion);\\
\ \ \ \ \underline\ info.open(INFO,ios::out);\\
\ \ \ \ escribirFila(1,\underline\ info,\underline\ posicion);\\
\ \ \ \ \underline\ info.close();\\
\ \ \}\\
\ \\
\ \ else\\
\ \ \{\\
\ \ \ \ \underline\ impacto\ =\ new\ Matriz(1,\underline\ dimension);\\
\ \ \ \ \underline\ transEnemigo\ =\ new\ Matriz(\underline\ dimension,\underline\ dimension);\\
\ \ \ \ llenarFila(1,\underline\ fileDatos,\underline\ impacto);\\
\ \ \ \ for(Tam\ i=1;i<{}=\underline\ dimension;i++)\\
\ \ \ \ \ \ llenarFila(i,\underline\ fileDatos,\underline\ transEnemigo);\\
\ \ \ \ \underline\ info.open(INFO);\\
\ \ \ \ llenarFila(1,\underline\ info,\underline\ posicion);\\
\ \ \ \ \underline\ info.close();
\\
\ \ \ \ \ \ \ \ \underline\ impacto-{}>{}trasponer();\\
\ \ \ \ \textsl{//levantar\ datos\ auxiliares\ si\ es\ que\ los\ hay!!!}\\
\ \ \}\\
\ \ \underline\ posicion-{}>{}trasponer();\\
\}\\
int\ Espionaje::getDimension()\ const\\
\{\\
\ \ return\ \underline\ dimension;\\
\}\\
\ \\
int\ Espionaje::getTurno()\ const\\
\{\\
\ \ return\ \underline\ turno;\\
\}\\
\ \\
Matriz$\ast$\ Espionaje::getPosicionNuestra()\ const\\
\{\\
\ \ return\ \underline\ posicion;\\
\}\\
Matriz$\ast$\ Espionaje::getPosicionImpacto()\ const\\
\{\\
\ \ return\ \underline\ impacto;\\
\}\\
\ \\
Matriz$\ast$\ Espionaje::getMatrizEnemigo()\ const\\
\{\\
\ \ return\ \underline\ transEnemigo;\\
\}\\
\ \\
void\ Espionaje::escibirInformacionAdicional()\\
\{\\
\ \ \underline\ info.open(INFO,ios::out\ |\ ios::app);\\
\ \ escribirFila(1,\underline\ info,\underline\ impacto);\\
\ \ \underline\ info.close();\\
\}\\
\ \\
void\ Espionaje::escribirDisparo()\\
\{\\
\ \ \underline\ fileDisparo<{}<{}\underline\ turno+1<{}<{}endl;\\
\ \ \underline\ fileDisparo<{}<{}\underline\ dimension<{}<{}endl;\\
\ \\
\ \ for(Tam\ j=1;j<{}=\underline\ dimension;j++)\\
\ \ \ \ \underline\ fileDisparo<{}<{}\underline\ nuestroDisparo-{}>{}get(j,1)<{}<{}'\ ';\\
\ \ \underline\ fileDisparo<{}<{}endl;\\
\ \\
\ \ for(Tam\ i=1;i<{}=\underline\ dimension;i++)\\
\ \ \{\\
\ \ \ \ for(Tam\ j=1;j<{}=\underline\ dimension;j++)\\
\ \ \ \ \ \ \underline\ fileDisparo<{}<{}\underline\ nuestraTransformacion-{}>{}get(i,j)<{}<{}'\ ';\\
\ \ \ \ \underline\ fileDisparo<{}<{}endl;\\
\ \ \}\\
\}\\
\ \\
void\ Espionaje::setDisparo(const\ Matriz$\ast$\ disparo)\\
\{\\
\ \ \underline\ nuestroDisparo\ =\ new\ Matriz(disparo-{}>{}cantidadDeFilas(),disparo-{}>{}cantidadDeColumnas());\\
\ \ \underline\ nuestroDisparo-{}>{}copiarMatriz(disparo);\\
\}\\
\ \\
void\ Espionaje::setTransformacion(const\ Matriz$\ast$\ transformacion)\\
\{\\
\ \ \underline\ nuestraTransformacion\ =\ new\ Matriz(transformacion-{}>{}cantidadDeFilas(),transformacion-{}>{}cantidadDeColumnas());\\
\ \ \underline\ nuestraTransformacion-{}>{}copiarMatriz(transformacion);\\
\}\\
\ \\
Espionaje::\textasciitilde Espionaje()\\
\{\\
\ \ \underline\ fileDatos.close();\\
\ \ \underline\ fileDisparo.close();\\
\ \ if(!\underline\ posicion)\\
\ \ \ \ delete\ \underline\ posicion;\\
\ \ if(!\underline\ impacto)\\
\ \ \ \ delete\ \underline\ impacto;\\
\ \ if(!\underline\ transEnemigo)\\
\ \ \ \ delete\ \underline\ transEnemigo;\\
\ \ if(!\underline\ nuestraTransformacion)\\
\ \ \ \ delete\ \underline\ nuestraTransformacion;\\
\ \ if(!\underline\ nuestroDisparo)\\
\ \ \ \ delete\ \underline\ nuestroDisparo;\\
\}\\
\ \\
 }
\normalfont\normalsize


\subsection{Localizador}
{\ttfamily \raggedright \small
\#ifndef LOCALIZADOR\underline\ H\underline\ \\
\#define LOCALIZADOR\underline\ H\underline\ \\
\#include\ "{}matriz.h"{}\\
\ \\
class\ Localizador\\
\{\\
\ \ private:\\
\ \\
\ \ public:\\
\ \ \ \ int\ getPosicionObjetivo(Matriz,\ Matriz,\ Matriz\&);\\
\};\\
\ \\
\#endif /$\ast$LOCALIZADOR\underline\ H\underline\ $\ast$/\\
\ \\
 }
\normalfont\normalsize


{\ttfamily \raggedright \small
\#include\ "{}localizador.h"{}
\\
\#include\ <{}fstream>{}
\\
using\ namespace\ std;
\\
\ \\
\ \\
int\ Localizador::getPosicionObjetivo(Matriz\ posicionImpacto,\ Matriz\ matrizEnemigo,\ Matriz\&\ posicionObjetivo)\{
\\
\ \ vector<{}int>{}\ arrSwap(posicionImpacto.cantidadDeFilas());\\
\ \ double\ coef;
\\
\ \ cout<{}<{}matrizEnemigo<{}<{}endl;\\
\ \ Indice\ i,\ j,\ k,\ filaMax,\ columnaMax,\ fin;\\
\ \ int\ solUnica=\ 0;\\
\ \ \textsl{//Eliminacion\ Gaussiana\ con\ pivoteo\ total}\\
\ \ fin=matrizEnemigo.cantidadDeColumnas();
\\
\ \ for(k=1;k<{}=fin;\ k++)\{\\
\ \ \ \ matrizEnemigo.getPosicionMaxElementoSubmatriz(k,filaMax,columnaMax);\\
\ \\
\ \ \ \ \textsl{//matrizEnemigo.swapColumna(k,columnaMax);}\\
\ \ \ \ \textsl{//matrizEnemigo.swapFila(k,filaMax);}\\
\ \ \ \ \textsl{//posicionImpacto.swapFila(k,filaMax);}\\
\ \ \ \ arrSwap[k-{}1]=\ filaMax;\\
\ \\
\ \ \ \ if\ (matrizEnemigo.get(k,k)\ !=0)\{\\
\ \ \ \ \ \ for(i=k+1;i<{}=matrizEnemigo.cantidadDeFilas();i++)\{\\
\ \ \ \ \ \ \ \ coef=\ matrizEnemigo.get(i,k)\ /\ matrizEnemigo.get(k,k);\\
\ \ \ \ \ \ \ \ matrizEnemigo.set(i,k,0);\\
\ \ \ \ \ \ \ \ for(j=k+1;j<{}=matrizEnemigo.cantidadDeColumnas();j++)\\
\ \ \ \ \ \ \ \ \ \ matrizEnemigo.set(i,j,matrizEnemigo.get(i,j)\ -{}\ matrizEnemigo.get(k,j)$\ast$coef);\\
\ \ \ \ \ \ \ \ posicionImpacto.set(i,1,posicionImpacto.get(i,1)\ -{}\ posicionImpacto.get(k,1)$\ast$coef);\\
\ \ \ \ \ \ \}\\
\ \ \ \ \}\\
\ \ \ \ else\\
\ \ \ \ \ \ solUnica=\ 1;\\
\ \ \}\\
\ \\
\ \ \textsl{//Solucion}\\
\ \ for(k=matrizEnemigo.cantidadDeFilas();\ k>{}0;\ k-{}-{})\{\\
\ \ \ \ posicionObjetivo.set(k,1,posicionImpacto.get(k,1));\\
\ \ \ \ for(i=k+1;\ i<{}=matrizEnemigo.cantidadDeColumnas();\ i++)\\
\ \ \ \ \ \ posicionObjetivo.set(k,1,\ posicionObjetivo.get(k,1)\ -{}\ (matrizEnemigo.get(k,i)$\ast$posicionObjetivo.get(i,1)));\\
\ \ \ \ if\ (matrizEnemigo.get(k,k)==0)\\
\ \ \ \ \ \ posicionObjetivo.set(k,1,posicionObjetivo.get(k,1));\\
\ \ \ \ else\\
\ \ \ \ \ \ posicionObjetivo.set(k,1,posicionObjetivo.get(k,1)/matrizEnemigo.get(k,k));\\
\ \ \}\\
\ \\
\ \ \textsl{//revierte\ las\ filas\ intercambiadas}\\
\ \ \textsl{//for\ (i=arrSwap.size();i>{}=1\ ;\ i-{}-{})}\\
\ \ \textsl{//\ \ posicionObjetivo.swapFila(i,arrSwap[i-{}1]);}\\
\ \\
\ \ return\ solUnica;\\
\}\\
\ \\
 }
\normalfont\normalsize


\subsection{Disparar}
{\ttfamily \raggedright \small
\#ifndef DISPARAR\underline\ H\underline\ \\
\#define DISPARAR\underline\ H\underline\ \\
\#include\ "{}matriz.h"{}\\
\ \\
class\ Disparar\\
\{\\
\ \ private:\\
\ \ \ \ Matriz$\ast$\ \underline\ hilbert;\\
\ \ \ \ Tam\ \underline\ dimension;\\
\ \ \ \ Matriz$\ast$\ \underline\ auxiliar;\ \\
\ \ public:\\
\ \ \ \ Disparar(Tam\ dim,const\ Matriz$\ast$\ pos);\\
\ \ \ \ void\ getTransformacion(const\ Matriz$\ast$\ ene,Matriz$\ast$\ trans);\\
\ \ \ \ void\ getPrimerDisparo(Matriz$\ast$\ disparo);\\
\ \ \ \ void\ getPrimerTransformacion(Matriz$\ast$\ trans);\\
\ \ \ \ \textasciitilde Disparar();\\
\};\\
\ \\
\#endif /$\ast$DISPARAR\underline\ H\underline\ $\ast$/\\
\ \\
 }
\normalfont\normalsize


{\ttfamily \raggedright \small
\#include\ "{}disparar.h"{}\\
\ \\
Disparar::Disparar(Tam\ dim,const\ Matriz$\ast$\ pos)\\
\{\\
\ \ Indice\ i,j;\\
\ \ \underline\ dimension\ =\ dim;\\
\ \ \underline\ hilbert\ =\ new\ Matriz(\underline\ dimension,\underline\ dimension);\\
\ \ for(i=1;i<{}=\underline\ dimension;i++)\\
\ \ \ \ for(j=1;j<{}=\underline\ dimension;j++)
\\
\ \ \ \ \{\\
\ \ \ \ \ \ \underline\ hilbert-{}>{}set(i,j,double(1.00/(i+j-{}1)));
\\
\ \ \ \ \ \ \ \ \ \ \ \ \textsl{/$\ast$if(i==j)
\\
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \underline\ hilbert-{}>{}set(i,j,1.00);
\\
\ \ \ \ \ \ \ \ \ \ \ \ else
\\
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \underline\ hilbert-{}>{}set(i,j,0.00);$\ast$/}
\\
\ \ \ \ \}\\
\ \\
\ \ \underline\ auxiliar\ =\ new\ Matriz(\underline\ dimension,1);\\
\ \\
\ \ double\ valor;\\
\ \ for(i=1;i<{}=\underline\ dimension;i++)\\
\ \ \{\\
\ \ \ \ valor=0;\\
\ \ \ \ for(j=1;j<{}=\underline\ dimension;j++)\\
\ \ \ \ \ \ valor+=\underline\ hilbert-{}>{}get(i,j)\ $\ast$\ pos-{}>{}get(j,1);\\
\ \ \ \ \underline\ auxiliar-{}>{}set(i,1,valor);\\
\ \ \}\\
\}\\
\ \\
\textsl{//devuelve\ la\ transformacion\ en\ la\ matriz\ trans}\\
void\ Disparar::getTransformacion(const\ Matriz$\ast$\ ene,Matriz$\ast$\ trans)\\
\{\\
\ \ Indice\ i,j;\\
\ \ vector<{}double>{}\ diagonal(\underline\ dimension);\\
\ \ for(i=1;i<{}=\underline\ dimension;i++)\\
\ \ \{\\
\ \ \ \ if(ene-{}>{}get(i,1)\ <{}=\ 1e-{}6\ ||\ \underline\ auxiliar-{}>{}get(i,1)\ <{}=\ 1e-{}6)\\
\ \ \ \ \ \ diagonal[i-{}1]\ =\ 0.0001;\\
\ \ \ \ else\\
\ \ \ \ \ \ \textsl{//diagonal[i]\ =\ \underline\ auxiliar-{}>{}get(i,1)\ /\ ene-{}>{}get(i,1);
}\\
\ \ \ \ \ \ diagonal[i-{}1]\ =\ ene-{}>{}get(i,1)\ /\ \underline\ auxiliar-{}>{}get(i,1);\\
\ \ \}\\
\ \\
\ \ for(i=1;i<{}=\underline\ dimension;i++)\\
\ \ \ \ for(j=1;j<{}=\underline\ dimension;j++)\\
\ \ \ \ \ \ trans-{}>{}set(i,j,diagonal[i-{}1]\ $\ast$\ \underline\ hilbert-{}>{}get(i,j));\\
\}\\
\ \\
void\ Disparar::getPrimerDisparo(Matriz$\ast$\ disparo)\\
\{\\
\ \ disparo-{}>{}copiarMatriz(\underline\ auxiliar);\\
\}\\
\ \\
void\ Disparar::getPrimerTransformacion(Matriz$\ast$\ trans)\\
\{\\
\ \ trans-{}>{}copiarMatriz(\underline\ hilbert);\\
\}\\
\ \\
Disparar::\textasciitilde Disparar()\\
\{\\
\ \ if(!\underline\ hilbert)\\
\ \ \ \ delete\ \underline\ hilbert;\\
\ \ if(!\underline\ auxiliar)\\
\ \ \ \ delete\ \underline\ auxiliar;\\
\}\\
\ \\
 }
\normalfont\normalsize
\newpage
